// 通用工具函数

// 数据采集器基类
class DataCollector {
  constructor(platformName) {
    this.platformName = platformName;
    this.isCollecting = false;
    this.lastMessageId = null;
    
    // ⭐ 添加任务采集相关的实例变量
    this.currentTaskId = 0;      // 当前任务ID
    this.currentQuestionId = 0;  // 当前问句ID
    
    // 🔧 新增：记录发送消息前的AI消息数量（用于找到新消息）
    this.aiMessageCountBeforeSend = 0;
  }

  // 初始化
  async init() {
    console.log(`[${this.platformName}] 数据采集器已初始化`);
    
    // 加载设置
    const settings = await chrome.storage.sync.get({
      autoCollect: true,
      syncToBackend: true,
      backendUrl: 'http://localhost:8080',
      stableWaitTime: 2  // 默认等待2秒
    });
    
    this.settings = settings;
    console.log(`[${this.platformName}] 设置：等待稳定时间 ${settings.stableWaitTime} 秒`);
    
    // 如果开启自动采集，开始监听
    if (settings.autoCollect) {
      this.startCollecting();
    }
    
    // 监听来自popup的消息
    chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
      this.handleMessage(message, sender, sendResponse);
      return true; // 保持消息通道打开
    });
  }

  // 开始采集
  startCollecting() {
    if (this.isCollecting) return;
    
    console.log(`[${this.platformName}] 开始采集数据`);
    this.isCollecting = true;
    
    // 启动DOM监听
    this.observeDOM();
  }

  // 停止采集
  stopCollecting() {
    if (!this.isCollecting) return;
    
    console.log(`[${this.platformName}] 停止采集数据`);
    this.isCollecting = false;
    
    if (this.observer) {
      this.observer.disconnect();
    }
  }

  // 观察DOM变化
  observeDOM() {
    // 由子类实现具体的选择器
    const targetNode = this.getTargetNode();
    if (!targetNode) {
      console.warn(`[${this.platformName}] 未找到目标节点`);
      return;
    }

    const config = { childList: true, subtree: true };
    
    this.observer = new MutationObserver((mutations) => {
      this.handleDOMChange(mutations);
    });
    
    this.observer.observe(targetNode, config);
  }

  // 处理DOM变化（由子类实现）
  handleDOMChange(mutations) {
    // 子类实现
  }

  // 获取目标节点（由子类实现）
  getTargetNode() {
    return document.body;
  }

  // 提取对话数据（由子类实现）
  extractConversation() {
    return null;
  }

  // 发送消息到页面（由子类实现）
  async sendMessage(message) {
    throw new Error('sendMessage 必须由子类实现');
  }

  // 等待响应完成（由子类实现）
  async waitForResponse(timeout = 60000) {
    throw new Error('waitForResponse 必须由子类实现');
  }

  // 获取最新响应
  getLatestResponse() {
    // 由子类实现
    return null;
  }

  // 检查登录状态（由子类实现）
  isLoggedIn() {
    return false;
  }

  // 保存数据
  async saveData(data) {
    console.log(`[${this.platformName}] saveData收到的数据:`, data);
    console.log(`[${this.platformName}] data.userMessage:`, data.userMessage);
    console.log(`[${this.platformName}] data.aiResponse:`, data.aiResponse ? data.aiResponse.substring(0, 100) : 'null');
    
    // ⭐ 验证数据有效性
    if (!data.userMessage || !data.aiResponse) {
      console.error(`[${this.platformName}] 数据无效，userMessage或aiResponse为空，跳过保存`);
      console.error(`[${this.platformName}] userMessage:`, data.userMessage);
      console.error(`[${this.platformName}] aiResponse:`, data.aiResponse ? data.aiResponse.substring(0, 50) : 'null');
      return;
    }
    
    const conversation = {
      platform: this.platformName,
      question: data.userMessage,       // 用户问题
      answer: data.aiResponse,           // AI回答（纯文本）
      answerHTML: data.aiResponseHTML || data.aiResponse,  // AI回答（HTML格式）
      userMessage: data.userMessage,     // 保留兼容性
      aiResponse: data.aiResponse,       // 保留兼容性
      aiResponseHTML: data.aiResponseHTML,  // HTML格式
      timestamp: Date.now(),             // 使用时间戳（数字格式）
      url: window.location.href
    };
    
    console.log(`[${this.platformName}] 准备保存的对话数据:`, conversation);

    // 保存到本地缓存
    await this.cacheData(conversation);

    // 同步到后端
    if (this.settings.syncToBackend) {
      await this.syncToBackend(conversation);
    } else {
      console.log(`[${this.platformName}] syncToBackend已禁用，跳过后端同步`);
    }

    // 更新统计
    await this.updateStats();

    console.log(`[${this.platformName}] 数据已保存`, conversation);
  }

  // 缓存数据
  async cacheData(data) {
    const result = await chrome.storage.local.get('cachedData');
    const cachedData = result.cachedData || [];
    
    cachedData.push(data);
    
    // 限制缓存大小（最多1000条）
    if (cachedData.length > 1000) {
      cachedData.shift();
    }
    
    await chrome.storage.local.set({ cachedData });
  }

  // 同步到后端（使用新的任务采集接口）
  async syncToBackend(data) {
    try {
      console.log(`[${this.platformName}] 准备同步到后端，原始数据:`, data);
      
      // 🔧 检查是否是错误回答
      const isError = data.isError || false;
      const errorMsg = data.errorMessage || null;
      
      if (isError) {
        console.warn(`[${this.platformName}] ⚠️ 检测到错误回答，将标记为失败状态`);
      }
      
      // ⭐ 适配新接口的字段格式
      const requestBody = {
        taskId: this.currentTaskId || data.taskId || 0,  // ⭐ 优先使用保存的taskId
        questionId: this.currentQuestionId || data.questionId || 0,  // ⭐ 优先使用保存的questionId
        questionContent: data.question || data.questionContent || data.userMessage || '',
        platform: (data.platform || this.platformName || '').toLowerCase(),
        answerContent: data.answer || '',
        answerHtml: data.answerHTML || data.answerHtml || '',
        collectTime: new Date().toISOString(),
        responseTime: data.responseTime || 0,
        collectStatus: isError ? 'failed' : 'success',  // 🔧 根据是否错误设置状态
        errorMessage: errorMsg  // 🔧 如果有错误，记录错误信息
      };
      
      console.log(`[${this.platformName}] 使用taskId: ${requestBody.taskId}, questionId: ${requestBody.questionId}`);
      console.log(`[${this.platformName}] 采集状态: ${requestBody.collectStatus}`);
      
      console.log(`[${this.platformName}] 请求体:`, requestBody);
      
      // ⭐ 使用新接口路径
      const response = await fetch(`${this.settings.backendUrl}/api/collect/submit`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(requestBody)
      });

      if (!response.ok) {
        const errorText = await response.text();
        console.error(`[${this.platformName}] HTTP错误 ${response.status}:`, errorText);
        throw new Error(`HTTP ${response.status}: ${errorText}`);
      }
      
      const result = await response.json();
      console.log(`[${this.platformName}] 后端响应:`, result);
      
      if (result.code !== 200) {
        throw new Error(result.message || '上报失败');
      }

      console.log(`[${this.platformName}] 数据已同步到后端，resultId: ${result.data.resultId || 'N/A'}`);
      
      // ⭐ 上报成功后，清除任务上下文（避免下次自动采集时误用）
      this.currentTaskId = 0;
      this.currentQuestionId = 0;
      console.log(`[${this.platformName}] 任务上下文已清除`);
      
    } catch (e) {
      console.error(`[${this.platformName}] 同步失败:`, e);
      throw e;  // 重新抛出错误，让调用者知道失败
    }
  }

  // 更新统计
  async updateStats() {
    const stats = await chrome.storage.local.get({
      todayCount: 0,
      totalCount: 0,
      lastDate: new Date().toDateString()
    });

    const today = new Date().toDateString();
    
    if (stats.lastDate !== today) {
      // 新的一天，重置今日计数
      stats.todayCount = 0;
      stats.lastDate = today;
    }

    stats.todayCount++;
    stats.totalCount++;

    await chrome.storage.local.set(stats);
  }

  // 处理消息
  async handleMessage(message, sender, sendResponse) {
    switch (message.action) {
      case 'checkLoginStatus':
        sendResponse({ loggedIn: this.isLoggedIn() });
        break;
        
      case 'sendMessage':
        try {
          console.log(`\n========== [${this.platformName}] 收到sendMessage请求 ==========`);
          console.log(`[${this.platformName}] 请求数据:`, message);
          
          // ⭐ 保存任务ID和问句ID（用于后续上报）
          this.currentTaskId = message.taskId || 0;
          this.currentQuestionId = message.questionId || 0;
          
          console.log(`[${this.platformName}] 保存上下文 - taskId: ${this.currentTaskId}, questionId: ${this.currentQuestionId}`);
          
          // ⭐ 关键：任务采集时，临时禁用自动采集（避免重复上报和标记冲突）
          const wasCollecting = this.isCollecting;
          if (this.currentTaskId > 0) {
            console.log(`[${this.platformName}] 任务采集模式，临时停止自动采集监听`);
            this.stopCollecting();
          }
          
          // 🔧 关键修复：记录发送前的AI消息数量
          this.recordAIMessageCountBeforeSend();
          
          // 获取消息内容（兼容不同字段名）
          const messageText = message.message || message.text || '';
          console.log(`[${this.platformName}] 准备发送消息: ${messageText.substring(0, 50)}...`);
          
          console.log(`[${this.platformName}] 🚀 步骤A: 发送消息到AI平台...`);
          await this.sendMessage(messageText);
          console.log(`[${this.platformName}] ✅ 步骤A完成`);
          
          console.log(`[${this.platformName}] 🚀 步骤B: 等待AI响应...`);
          await this.waitForResponse();
          console.log(`[${this.platformName}] ✅ 步骤B完成`);
          
          // ⭐ 重要：提取完整的对话数据（包括问句和回答）
          console.log(`[${this.platformName}] 🚀 步骤C: 提取对话数据...`);
          const conversation = this.extractConversation();
          
          if (!conversation) {
            console.error(`[${this.platformName}] ❌ 步骤C失败: 提取对话数据失败`);
            throw new Error('提取对话数据失败');
          }
          
          console.log(`[${this.platformName}] ✅ 步骤C完成: 对话数据提取成功`);
          console.log(`[${this.platformName}] 数据详情:`, {
            userMessage: conversation.userMessage ? conversation.userMessage.substring(0, 50) + '...' : 'null',
            aiResponse: conversation.aiResponse ? conversation.aiResponse.substring(0, 50) + '...' : 'null',
            aiResponseLength: conversation.aiResponse ? conversation.aiResponse.length : 0,
            hasHTML: !!conversation.aiResponseHTML,
            isError: !!conversation.isError
          });
          
          // ⭐ 构造返回数据，匹配popup.js期望的格式
          const responseData = {
            question: conversation.userMessage,
            answer: conversation.aiResponse,
            answerHtml: conversation.aiResponseHTML || conversation.aiResponse
          };
          
          console.log(`[${this.platformName}] 🚀 步骤D: 准备返回数据给popup.js...`);
          
          // ⭐ 恢复自动采集状态
          if (wasCollecting && this.currentTaskId > 0) {
            console.log(`[${this.platformName}] 恢复自动采集监听`);
            this.startCollecting();
          }
          
          console.log(`[${this.platformName}] ⭐⭐⭐ 调用sendResponse ⭐⭐⭐`);
          sendResponse({ success: true, response: responseData });
          console.log(`[${this.platformName}] ⭐⭐⭐ sendResponse调用成功 ⭐⭐⭐`);
          console.log(`========== [${this.platformName}] 处理完成 ==========\n`);
          
        } catch (e) {
          console.error(`========== [${this.platformName}] 处理失败 ==========`);
          console.error(`[${this.platformName}] ❌ 错误:`, e);
          console.error(`[${this.platformName}] ❌ 错误消息:`, e.message);
          console.error(`[${this.platformName}] ❌ 错误堆栈:`, e.stack);
          
          console.log(`[${this.platformName}] ⭐⭐⭐ 调用sendResponse(error) ⭐⭐⭐`);
          sendResponse({ success: false, error: e.message });
          console.log(`[${this.platformName}] ⭐⭐⭐ sendResponse(error)调用成功 ⭐⭐⭐`);
          console.log(`========== [${this.platformName}] 处理完成（失败） ==========\n`);
        }
        break;
        
      case 'startCollecting':
        this.startCollecting();
        sendResponse({ success: true });
        break;
        
      case 'stopCollecting':
        this.stopCollecting();
        sendResponse({ success: true });
        break;
        
      case 'updateSettings':
        // 更新设置
        this.settings = message.settings;
        console.log(`[${this.platformName}] 设置已更新:`, this.settings);
        sendResponse({ success: true });
        break;
        
      default:
        sendResponse({ success: false, error: 'Unknown action' });
    }
  }

  // 工具函数：等待元素出现
  waitForElement(selector, timeout = 10000) {
    return new Promise((resolve, reject) => {
      const element = document.querySelector(selector);
      if (element) {
        resolve(element);
        return;
      }

      const observer = new MutationObserver(() => {
        const element = document.querySelector(selector);
        if (element) {
          observer.disconnect();
          resolve(element);
        }
      });

      observer.observe(document.body, {
        childList: true,
        subtree: true
      });

      setTimeout(() => {
        observer.disconnect();
        reject(new Error(`元素 ${selector} 超时未出现`));
      }, timeout);
    });
  }

  // 工具函数：模拟人类输入
  simulateTyping(element, text) {
    element.focus();
    
    // 对于contenteditable元素（如元宝的输入框）
    if (element.contentEditable === 'true' || element.getAttribute('contenteditable') === 'true') {
      // 清空内容
      element.innerHTML = '';
      element.textContent = text;
      
      // 触发输入事件
      ['input', 'change', 'keydown', 'keyup'].forEach(eventType => {
        const event = new Event(eventType, { bubbles: true, cancelable: true });
        element.dispatchEvent(event);
      });
      
      // 特殊的InputEvent
      const inputEvent = new InputEvent('input', {
        bubbles: true,
        cancelable: true,
        inputType: 'insertText',
        data: text
      });
      element.dispatchEvent(inputEvent);
    }
    // 对于普通input/textarea
    else {
      element.value = text;
      
      ['input', 'change', 'keydown', 'keyup'].forEach(eventType => {
        const event = new Event(eventType, { bubbles: true });
        element.dispatchEvent(event);
      });
    }
  }

  // 工具函数：点击元素
  simulateClick(element) {
    const events = ['mousedown', 'mouseup', 'click'];
    events.forEach(eventType => {
      const event = new MouseEvent(eventType, {
        bubbles: true,
        cancelable: true,
        view: window
      });
      element.dispatchEvent(event);
    });
  }
  
  // 🔧 新增：记录发送消息前的AI消息数量（子类可重写）
  recordAIMessageCountBeforeSend() {
    // 由子类实现具体的选择器
    // 默认实现：不做任何操作
    this.aiMessageCountBeforeSend = 0;
  }
}

// 导出
window.DataCollector = DataCollector;

